home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / tcp_ip / os2 / pmnos11s / rlogin.c < prev    next >
C/C++ Source or Header  |  1993-07-30  |  4KB  |  186 lines
  1. #include <stdio.h>
  2. #include <errno.h>
  3. #include "global.h"
  4. #include "mbuf.h"
  5. #include "socket.h"
  6. #include "session.h"
  7. #include "proc.h"
  8. #include "tty.h"
  9. #include "commands.h"
  10. #include "netuser.h"
  11.  
  12. static char *username = "guest";
  13. static char terminal[] = "ansi";
  14. static char *termspeed = "/38400";
  15.  
  16. extern FILE *Rawterm;
  17. int rlo_connect __ARGS((struct session *sp,char *fsocket,int len));
  18. void rlo_output __ARGS((int unused,void *p1,void *p2));
  19. void rlrecv __ARGS((struct session *sp));
  20.  
  21. /* Execute user rlogin command */
  22. int
  23. dorlogin(argc,argv,p)
  24. int argc;
  25. char *argv[];
  26. void *p;
  27. {
  28.     struct session *sp;
  29.     struct sockaddr_in fsocket;
  30.     struct sockaddr_in lsocket;
  31.  
  32.     /*Make sure this comes from console - WG7J*/
  33.     if(Curproc->input != Command->input)
  34.         return 0;
  35.  
  36.     /* Allocate a session descriptor */
  37.     if((sp = newsession(argv[1],RLOGIN,0)) == NULLSESSION){
  38.         tputs(TooManySessions);
  39.         return 1;
  40.     }
  41.     fsocket.sin_family = AF_INET;
  42.     if(argc < 3)
  43.         fsocket.sin_port = IPPORT_RLOGIN;
  44.     else
  45.         fsocket.sin_port = atoi(argv[2]);
  46.  
  47.     tprintf("Resolving %s... ",sp->name);
  48.     if((fsocket.sin_addr.s_addr = resolve(sp->name)) == 0L){
  49.         tprintf(Badhost,sp->name);
  50.         keywait(NULLCHAR,1);
  51.         freesession(sp);
  52.         return 1;
  53.     }
  54.     if((sp->s = socket(AF_INET,SOCK_STREAM,0)) == -1){
  55.         tputs(Nosock);
  56.         keywait(NULLCHAR,1);
  57.         freesession(sp);
  58.         return 1;
  59.     }
  60.     lsocket.sin_family = AF_INET;
  61.     lsocket.sin_addr.s_addr = INADDR_ANY;
  62.     lsocket.sin_port = IPPORT_RLOGIN;
  63.     bind(sp->s,(char *)&lsocket,sizeof(lsocket));
  64.     return rlo_connect(sp,(char *)&fsocket,SOCKSIZE);
  65. }
  66. /* Generic interactive connect routine */
  67. int
  68. rlo_connect(sp,fsocket,len)
  69. struct session *sp;
  70. char *fsocket;
  71. int len;
  72. {
  73.     unsigned int index;
  74.  
  75.     index = sp - Sessions;
  76.  
  77.     sockmode(sp->s,SOCK_ASCII);
  78.     tprintf("Trying %s...\n",psocket((struct sockaddr *)fsocket));
  79.     if(connect(sp->s,fsocket,len) == -1){
  80.           tprintf("%s session %u failed: %s errno %d\n",
  81.          Sestypes[sp->type], index, sockerr(sp->s),errno);
  82.  
  83.         keywait(NULLCHAR,1);
  84.         freesession(sp);
  85.         return 1;
  86.     }
  87.     tprintf("%s session ",Sestypes[sp->type]);
  88.     tprintf("%u connected to %s\n",index,sp->name);
  89.     rlrecv(sp);
  90.     return 0;
  91. }
  92.  
  93. /* Rlogin input routine, common to both rlogin and ttylink */
  94. void
  95. rlrecv(sp)
  96. struct session *sp;
  97. {
  98.     int c,s,index;
  99.     char *cp;
  100.  
  101.     s = sp->s;
  102.  
  103.     /* We run both the network and local sockets in transparent mode
  104.      * because we have to do our own eol mapping
  105.      */
  106.     seteol(s,"");
  107.     seteol(Curproc->input,"");
  108.     seteol(Curproc->output,"");
  109.  
  110.     /* Read real keystrokes from the keyboard */
  111.     sp->ttystate.crnl = 0;
  112.     /* Put tty into raw mode */
  113.     sp->ttystate.echo = 0;
  114.     sp->ttystate.edit = 0;
  115.  
  116.     setflush(s,'\n');
  117.  
  118.     index = sp - Sessions;
  119.  
  120.     /* Fork off the transmit process */
  121.     sp->proc1 = newproc("rlo_out",1024,rlo_output,0,sp,NULL,0);
  122.  
  123.     /* Process input on the connection */
  124.     while((c = recvchar(s)) != -1){
  125.         putc((char)c,Rawterm);
  126.     }
  127. quit:    /* A close was received from the remote host.
  128.      * Notify the user, kill the output task and wait for a response
  129.      * from the user before freeing the session.
  130.      */
  131.     cp = sockerr(s);
  132.     seteol(s,"\r\n");
  133.     seteol(Curproc->input,"\r\n");
  134.     seteol(Curproc->output,"\r\n");
  135.  
  136.     tprintf("%s session %u", Sestypes[sp->type],index);
  137.     tprintf(" closed: %s\n", cp != NULLCHAR ? cp : "EOF");
  138.     killproc(sp->proc1);
  139.     sp->proc1 = NULLPROC;
  140.     close_s(sp->s);
  141.     sp->s = -1;
  142.     keywait(NULLCHAR,1);
  143.     freesession(sp);
  144. }
  145.  
  146. /* User rlogin output task, started by user rlogin command */
  147. void
  148. rlo_output(unused,sp1,p)
  149. int unused;
  150. void *sp1;
  151. void *p;
  152. {
  153.     struct session *sp;
  154.     struct mbuf *bp;
  155.     char *cp;
  156.     char *logname;
  157.     sp = (struct session *)sp1;
  158.  
  159.     logname = getenv("USER");
  160.     if(logname == NULLCHAR)
  161.         logname = username;
  162.     bp = ambufw(1 + strlen(logname)+1 + strlen(logname)+1 +
  163.         strlen(terminal) + strlen(termspeed)+1);
  164.  
  165.     cp = bp->data;
  166.     *cp++ = '\0';
  167.     strcpy(cp, logname);
  168.     cp += strlen(logname) + 1;
  169.     strcpy(cp, logname);
  170.     cp += strlen(logname) + 1;
  171.     strcpy(cp, terminal);
  172.     cp += strlen(terminal);
  173.     strcpy(cp, termspeed);
  174.     cp += strlen(termspeed) + 1;
  175.     bp->cnt = cp - bp->data;
  176.     if(send_mbuf(sp->s,bp,0,NULLCHAR,0) != -1){
  177.         /* Send whatever's typed on the terminal */
  178.         while(recv_mbuf(sp->input,&bp,0,NULLCHAR,0) > 0){
  179.             if(send_mbuf(sp->s,bp,0,NULLCHAR,0) == -1)
  180.             break;
  181.         }
  182.     }
  183.     /* Make sure our parent doesn't try to kill us after we exit */
  184.     sp->proc1 = NULLPROC;
  185. }
  186.